﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using KPWeb.Class;

namespace KPWeb.Data
{
    public class Kalendarz
    {

        public static vKP_SwietaDodatkowe[] GetSwietaDodatkowe(int year, int firmaId, int grupaID)
        {
            using (DBContainer db = new DBContainer())
            {

                return (from wiz in db.vKP_SwietaDodatkowe.Where(a => a.year == year
                            && a.firmaID==firmaId && a.grupaID ==grupaID)
                        select wiz).ToArray();
            }
        }

        public static vKP_SwietaDodatkowe[] GetSwietaDodatkowe(int year, int month, int firmaId, int grupaID)
        {
            using (DBContainer db = new DBContainer())
            {

                return (from wiz in db.vKP_SwietaDodatkowe.Where(a => a.year == year
                            && a.month == month && a.firmaID == firmaId && a.grupaID == grupaID)
                        select wiz).ToArray();
            }
        }

        public static vKP_Swieta[] GetSwieta(int year, int month)
        {
            using (DBContainer db = new DBContainer())
            {
              return (from wiz in db.vKP_Swieta.Where(a => a.year == year && a.month == month) select wiz).ToArray();
           
            }
        }
        public static vKP_Swieta[] GetSwieta(int year)
        {
            using (DBContainer db = new DBContainer())
            {

                return (from wiz in db.vKP_Swieta.Where(a => a.year == year) select wiz).ToArray();
            }
        }

    
        public static  short[] GetYearGdzieWpisanoSwieta()
        {
            using (DBContainer db = new DBContainer())
            {
                //(from wiz in db.vlexStawkiStanowiskoTytuls
                //            orderby wiz.Specjalizacja
                //            where (wiz.Rok == rokAkad) && (wiz.Specjalizacja != null)
                //            select wiz.Specjalizacja).Distinct().ToArray();
                return (from wiz in db.vKP_Swieta orderby wiz.year select wiz.year).Distinct().ToArray();
            }
        } 
        public static int GetLiczbaDniRoboczych(DateTime[] SelectedDates)
        {

            int iRob = 0;
            foreach (DateTime d in SelectedDates)
                if (d.DayOfWeek != DayOfWeek.Saturday && d.DayOfWeek != DayOfWeek.Sunday
                    && Kalendarz.GetSwieta(d.Year).Where(a => a.day == d.Day && a.month == d.Month).Count() == 0) iRob += 1;

            return iRob;
        }


        public static int GetLiczbaDniWolnych(DateTime dataP,DateTime dataK)
        {
            DateTime dData = dataP;
            int iRob = 0;
            for (int i = 0; i < (dataK - dataP).Days; i++)
            {
                dData = dData.AddDays(1);
                if (dData.DayOfWeek == DayOfWeek.Saturday || dData.DayOfWeek == DayOfWeek.Sunday
                     || Kalendarz.GetSwieta(dData.Year).Where(a => a.day == dData.Day && a.month == dData.Month).Count() == 1) iRob += 1;
            }
            return iRob;
        }
        public static DateTime[] GetMinMaxOkresu(DateTime[] SelectedDates)
        {
            DateTime[] iRob = new DateTime[2];
            iRob[0] = SelectedDates.Min();
            iRob[1] = SelectedDates.Max();
            return iRob;
        }
        public static bool CzyDzienWolny(DateTime data)
        {

            if (data.DayOfWeek == DayOfWeek.Saturday || data.DayOfWeek == DayOfWeek.Sunday
                      || Kalendarz.GetSwieta(data.Year).Where(a => a.day == data.Day && a.month == data.Month).Count() == 1)
                return true;
            else return false;
        }
        public static bool CzySwieto(DateTime data,int firmaID, int grupaID)
        {
           
            if ( Kalendarz.GetSwieta(data.Year).Where(a => a.day == data.Day && a.month == data.Month).Count() == 1
                ||  Kalendarz.GetSwietaDodatkowe(data.Year,firmaID,grupaID).Where(a => a.day == data.Day && a.month == data.Month).Count() == 1)
                return true;
            else return false;
        }

        public static string[] ZamienDniNaOkresy(DateTime[] dni,short rok)
        {

            string[] iSt = new string[2];
            bool bTemp = false; //ciągłość daty
            string sTemp = "";
            int liczbaDni = 0, iTemp;
            DateTime dTempI = new DateTime(rok, 1, 1);
            DateTime dTempP = new DateTime(rok, 1, 1);
            DateTime dTempK = new DateTime(rok, 1, 1);
            for (int i = 0; i < (rok % 4 == 0 ? 366 : 365); i++)  //nie jest podzielny przez 100 lub jest podzielny przez 400 
            {
                dTempI = dTempI.AddDays(1);
                if (!Kalendarz.CzyDzienWolny(dTempI))
                {
                    if (dni.Contains(dTempI))
                    {
                        if (bTemp)
                        {//

                            dTempK = dTempI;
                        }
                        else
                        {//
                            bTemp = true;
                            sTemp += dTempI.ToShortDateString().Substring(0, 5);
                            dTempP = dTempI;
                            dTempK = dTempI;
                        }


                    }
                    else
                    {
                        if (bTemp)
                        {//
                            bTemp = false;
                            if (dTempP == dTempK)
                            {
                                sTemp += "(1);   ";
                                liczbaDni += 1;
                            }
                            else
                            {

                                iTemp = (dTempK - dTempP).Days + 1 - Kalendarz.GetLiczbaDniWolnych(dTempP, dTempK);
                                liczbaDni += iTemp;
                                sTemp += ":" + dTempK.ToShortDateString().Substring(0, 5) + "(" + iTemp.ToString() + ");   "; // odjąć wolne
                            }
                        }
                        else
                        {
                            dTempP = dTempI;
                        }


                    }
                }


            }
            iSt[0] = sTemp;
            iSt[1] = liczbaDni.ToString();
            return iSt;
        }








    
    }
    public class UrlopyK
    {

        public  Boolean CzyWprowadzonoUrlopyZalegle(int osobaID, int year)
            //warunek konieczny dla rozpoczęcia pracy w jednostce
        {
            using (DBContainer db = new DBContainer())
            {
                vKP_UrlopyNalezneZalegle urlop = db.vKP_UrlopyNalezneZalegle.Where(a => a.OsobaID == osobaID && a.Rok == year).SingleOrDefault();
                return (urlop!=null);
            }
        }
        public static int GetUrlopyZalegly(int osobaID, int year)
        {
            using (DBContainer db = new DBContainer())
            {
                int iTemp=db.vKP_UrlopyNalezneZalegle.Where(a => a.OsobaID == osobaID && a.Rok == year).Count();
                return (iTemp == 0 ? -1 :db.vKP_UrlopyNalezneZalegle.Where(a => a.OsobaID == osobaID && a.Rok == year).Single().UrlopZalegly);
            }
        }
        public static int GetUrlopyNalezny(int osobaID, int year)
        {
            using (DBContainer db = new DBContainer())
            {
                int iTemp = db.vKP_UrlopyNalezneZalegle.Where(a => a.OsobaID == osobaID && a.Rok == year).Count();
                return (iTemp == 0 ? -1 :db.vKP_UrlopyNalezneZalegle.Where(a => a.OsobaID == osobaID && a.Rok == year).Single().UrlopNalezny);
            }
        }

        public static IEnumerable<vLex_TypNieobecnosciUrlopu> GetListaTypUrlopu()
        {
            int iTemp = int.Parse(Stale.nieobecnoscInic);
            using (DBContainer db = new DBContainer())
            {
              return (db.vLex_TypNieobecnosciUrlopu.Where(a=>a.TypNieobecnosciUrlopuID<iTemp).ToArray());
            }
        }
      
        public static IEnumerable<vLex_TypNieobecnosciUrlopu> GetListaTypNieobecnosciUrlopu()
        {
            using (DBContainer db = new DBContainer())
            {
                return (db.vLex_TypNieobecnosciUrlopu.OrderBy(a => a.TypNieobecnosciUrlopuID).ToArray());
            }
        }

    
        public static IEnumerable<vLex_TypNieobecnosciUrlopu> GetListaTypNieobecnosciNieUrlop()
        {
            int iTemp = int.Parse(Stale.nieobecnoscInic);
            using (DBContainer db = new DBContainer())
            {
                return (db.vLex_TypNieobecnosciUrlopu.Where(a => a.TypNieobecnosciUrlopuID >= iTemp).ToArray());
            }
        }

        public static vKP_DrukWniosekUrlopowy[] GetDrukWniosekUrlopowy(int wniosekUrlopowyID)
        {
            using (DBContainer db = new DBContainer())
            {

                return (from wiz in db.vKP_DrukWniosekUrlopowy.Where(a => a.WnioskiUrlopoweID == wniosekUrlopowyID)
                        select wiz).ToArray();
            }
        }
        public static int GetOsobaIDWniosekUrlopowy(int wniosekUrlopowyID)
        {
            using (DBContainer db = new DBContainer())
            {
                int iTemp = db.vKP_DrukWniosekUrlopowy.Where(a => a.WnioskiUrlopoweID == wniosekUrlopowyID).Count();
                return (iTemp == 0 ? -1 : db.vKP_DrukWniosekUrlopowy.Where(a => a.WnioskiUrlopoweID == wniosekUrlopowyID).Single().OsobaID);
            }
        }
        public static int GetStanWniosekUrlopowy(int wniosekUrlopowyID)
        {
            using (DBContainer db = new DBContainer())
            {
                int iTemp = db.vKP_DrukWniosekUrlopowy.Where(a => a.WnioskiUrlopoweID == wniosekUrlopowyID).Count();
                return (iTemp == 0 ?-1 : db.vKP_DrukWniosekUrlopowy.Where(a => a.WnioskiUrlopoweID == wniosekUrlopowyID).Single().stan);
            }
        }
        public static vKP_DokumentyWnioskiUrlopowe[] GetWnioskiUrlopowe(int osobaID)
        {
            using (DBContainer db = new DBContainer())
            {

                return (from wiz in db.vKP_DokumentyWnioskiUrlopowe.Where(a => a.OsobaID == osobaID)
                        select wiz).OrderByDescending(a=>a.OdData).ToArray();
            }
        }
        public static vKP_DokumentyWnioskiUrlopowe[] GetWnioskiUrlopoweJednostka(int jednostkaID, int rok)
        {
            using (DBContainer db = new DBContainer())
            {

                return (from wiz in db.vKP_DokumentyWnioskiUrlopowe.Where(a => a.JednostkaGlownaID == jednostkaID
                    && (a.OdData.Year==rok || a.DoData.Year==rok) )
                        select wiz).ToArray();
            }
        }
        public static vKP_DokumentyWnioskiUrlopowe[] GetWnioskiUrlopoweStan(int stan)
            // stan 5 przesłane do KADR
        {
            using (DBContainer db = new DBContainer())
            {

                return (from wiz in db.vKP_DokumentyWnioskiUrlopowe.Where(a => a.stan==stan)
                        select wiz).ToArray();
            }
        }
        public static int UpdateWniosekUrlopowy(int wnioskiUrlopoweID, byte stan1, byte stan2)
        {
            
            using (DBContainer db = new DBContainer())
            {
                //try
                //{
                //    var wiz = db.KP_DokumentyWnioskiUrlopowe.Where(a => a.WnioskiUrlopoweID == wnioskiUrlopoweID && a.Stan == stan1).ToArray();

                //    foreach (KP_DokumentyWnioskiUrlopowe e in wiz)
                //    {
                //       e.Stan = stan2;
     
                //    }


                //    db.SaveChanges();
                //    return 0;
                //}
                //catch (Exception e)
                //{
                //    return 1;
                //}

                try
                {
                    KP_DokumentyWnioskiUrlopowe e = db.KP_DokumentyWnioskiUrlopowe.Where(a => a.WnioskiUrlopoweID == wnioskiUrlopoweID && a.Stan == stan1).SingleOrDefault();
                    e.Stan = stan2;

                    db.SaveChanges();
                    return 0;
                }
                catch (Exception e)
                {
                    return 1;
                }

            }
        }
        public static int InsertWniosekUrlopowy(int osobaID, byte typUrlopuID, int? zastepstwoOsobaID, 
               DateTime odData, DateTime doData, int dniRoboczych,byte rodzaj,byte stan )
            //-4 pokrywające się daty w juz utworzonych wnioskach 
            //-1 błąd zapisu
            //ID utworzonego rekordu
        {
           
            
            foreach( vKP_DokumentyWnioskiUrlopowe d in GetWnioskiUrlopowe(osobaID))
                {
                    if (doData >= d.OdData && doData <= d.DoData ||
                        odData >= d.OdData && odData <= d.DoData ||
                       odData <= d.OdData && doData >= d.DoData) return -4;
                }
           
            
            using (DBContainer db = new DBContainer())
            {
                try
                {
                    KP_DokumentyWnioskiUrlopowe e = new KP_DokumentyWnioskiUrlopowe();
                    e.OsobaID = osobaID;
                    e.TypNieobecnosciUrlopuID = typUrlopuID;
                    e.ZastepstwoOsobaID = zastepstwoOsobaID;
                    e.OdData = odData;
                    e.DoData = doData;
                    e.DniRoczych=dniRoboczych;
                    e.Stan=stan;
                    e.DataUtworzenia = DateTime.Now;
                    e.Rodzaj = rodzaj;
                    e.active = "t";
                    db.KP_DokumentyWnioskiUrlopowe.AddObject(e);
                  //  int a= db.SaveChanges();
                    db.SaveChanges();

                    return e.WnioskiUrlopoweID;
                }
                catch (Exception e)
                {
                    return -1;
                }

            }
        }
      
        public static int DeleteWniosekUrlopowy(int wniosekUrlopowyID)
        {
            //1 błąd operacji kasowania
            using (DBContainer db = new DBContainer())
            {
                //try
                //{
                //    db.KP_DokumentyWnioskiUrlopowe.DeleteObject(db.KP_DokumentyWnioskiUrlopowe.Where
                //              (a => a.WnioskiUrlopoweID ==wniosekUrlopowyID).Single());
                //      db.SaveChanges();
                //      return 0;
                //}
                //catch (Exception e)
                //{
                //    return 1;
                //}
                try
                {
                    KP_DokumentyWnioskiUrlopowe e = db.KP_DokumentyWnioskiUrlopowe.Where(a => a.WnioskiUrlopoweID == wniosekUrlopowyID).SingleOrDefault();
                    e.active = "f";

                    db.SaveChanges();
                    return 0;
                }
                catch (Exception e)
                {
                    return 1;
                }

            }
        }
        public vKP_DokumentyWnioskiUrlopowe GetObecnoscOsobyWnioskiUrlopowe(int osobaID,DateTime  date)
        {
            using (DBContainer db = new DBContainer())
            {

                return (from wiz in db.vKP_DokumentyWnioskiUrlopowe.Where(a => a.OsobaID == osobaID &&
                            a.OdData<= date && date<= a.DoData && a.stan>1 )
                        select wiz).SingleOrDefault();
            }
        }
    }

}